package com.tjbank.cssys.mybatis.sqlbuilder;

import com.tansun.web.framework.dao.SQLBulider;
import java.io.Serializable;
import java.util.Date;

/**
 * IamUserSqlBuilder
 * 
 * @author PG(Auto Generator)
 * @version V2.0
 */
public class IamUserSqlBuilder extends SQLBulider<IamUserSqlBuilder> implements Serializable {
    private static final long serialVersionUID = -161123581321345589L;

    public IamUserSqlBuilder() {
        _id = this.toString().split("@")[1];
    }

    public IamUserSqlBuilder andIdEqualTo(String value) {
        return addAndCriterion("ID", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andIdNotEqualTo(String value) {
        return addAndCriterion("ID", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andIdGreaterThan(String value) {
        return addAndCriterion("ID", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andIdGreaterThanOrEqualTo(String value) {
        return addAndCriterion("ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIdLessThan(String value) {
        return addAndCriterion("ID", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andIdLessThanOrEqualTo(String value) {
        return addAndCriterion("ID", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIdIsNull() {
        return addAndCriterion("ID", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andIdIsNotNull() {
        return addAndCriterion("ID", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andIdLikeBoth(String value) {
        return addAndCriterion("ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIdLikeLeft(String value) {
        return addAndCriterion("ID", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andIdLikeRigth(String value) {
        return addAndCriterion("ID", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andIdNotLikeBoth(String value) {
        return addAndCriterion("ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIdNotLikeLeft(String value) {
        return addAndCriterion("ID", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andIdNotLikeRigth(String value) {
        return addAndCriterion("ID", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orIdEqualTo(String value) {
        return addOrCriterion("ID", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orIdNotEqualTo(String value) {
        return addOrCriterion("ID", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orIdGreaterThan(String value) {
        return addOrCriterion("ID", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orIdGreaterThanOrEqualTo(String value) {
        return addOrCriterion("ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIdLessThan(String value) {
        return addOrCriterion("ID", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orIdLessThanOrEqualTo(String value) {
        return addOrCriterion("ID", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIdIsNull() {
        return addOrCriterion("ID", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orIdIsNotNull() {
        return addOrCriterion("ID", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orIdLikeBoth(String value) {
        return addOrCriterion("ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIdLikeLeft(String value) {
        return addOrCriterion("ID", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orIdLikeRigth(String value) {
        return addOrCriterion("ID", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orIdNotLikeBoth(String value) {
        return addOrCriterion("ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIdNotLikeLeft(String value) {
        return addOrCriterion("ID", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orIdNotLikeRigth(String value) {
        return addOrCriterion("ID", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderById(boolean isDesc) {
        return addOrderBy("ID", isDesc);
    }

    public IamUserSqlBuilder andUserTypeEqualTo(String value) {
        return addAndCriterion("USER_TYPE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andUserTypeNotEqualTo(String value) {
        return addAndCriterion("USER_TYPE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andUserTypeGreaterThan(String value) {
        return addAndCriterion("USER_TYPE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andUserTypeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("USER_TYPE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserTypeLessThan(String value) {
        return addAndCriterion("USER_TYPE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andUserTypeLessThanOrEqualTo(String value) {
        return addAndCriterion("USER_TYPE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserTypeIsNull() {
        return addAndCriterion("USER_TYPE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andUserTypeIsNotNull() {
        return addAndCriterion("USER_TYPE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andUserTypeLikeBoth(String value) {
        return addAndCriterion("USER_TYPE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserTypeLikeLeft(String value) {
        return addAndCriterion("USER_TYPE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andUserTypeLikeRigth(String value) {
        return addAndCriterion("USER_TYPE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andUserTypeNotLikeBoth(String value) {
        return addAndCriterion("USER_TYPE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserTypeNotLikeLeft(String value) {
        return addAndCriterion("USER_TYPE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andUserTypeNotLikeRigth(String value) {
        return addAndCriterion("USER_TYPE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orUserTypeEqualTo(String value) {
        return addOrCriterion("USER_TYPE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orUserTypeNotEqualTo(String value) {
        return addOrCriterion("USER_TYPE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orUserTypeGreaterThan(String value) {
        return addOrCriterion("USER_TYPE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orUserTypeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("USER_TYPE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserTypeLessThan(String value) {
        return addOrCriterion("USER_TYPE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orUserTypeLessThanOrEqualTo(String value) {
        return addOrCriterion("USER_TYPE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserTypeIsNull() {
        return addOrCriterion("USER_TYPE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orUserTypeIsNotNull() {
        return addOrCriterion("USER_TYPE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orUserTypeLikeBoth(String value) {
        return addOrCriterion("USER_TYPE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserTypeLikeLeft(String value) {
        return addOrCriterion("USER_TYPE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orUserTypeLikeRigth(String value) {
        return addOrCriterion("USER_TYPE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orUserTypeNotLikeBoth(String value) {
        return addOrCriterion("USER_TYPE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserTypeNotLikeLeft(String value) {
        return addOrCriterion("USER_TYPE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orUserTypeNotLikeRigth(String value) {
        return addOrCriterion("USER_TYPE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByUserType(boolean isDesc) {
        return addOrderBy("USER_TYPE", isDesc);
    }

    public IamUserSqlBuilder andUserCodeEqualTo(String value) {
        return addAndCriterion("USER_CODE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andUserCodeNotEqualTo(String value) {
        return addAndCriterion("USER_CODE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andUserCodeGreaterThan(String value) {
        return addAndCriterion("USER_CODE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andUserCodeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("USER_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserCodeLessThan(String value) {
        return addAndCriterion("USER_CODE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andUserCodeLessThanOrEqualTo(String value) {
        return addAndCriterion("USER_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserCodeIsNull() {
        return addAndCriterion("USER_CODE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andUserCodeIsNotNull() {
        return addAndCriterion("USER_CODE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andUserCodeLikeBoth(String value) {
        return addAndCriterion("USER_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserCodeLikeLeft(String value) {
        return addAndCriterion("USER_CODE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andUserCodeLikeRigth(String value) {
        return addAndCriterion("USER_CODE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andUserCodeNotLikeBoth(String value) {
        return addAndCriterion("USER_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserCodeNotLikeLeft(String value) {
        return addAndCriterion("USER_CODE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andUserCodeNotLikeRigth(String value) {
        return addAndCriterion("USER_CODE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orUserCodeEqualTo(String value) {
        return addOrCriterion("USER_CODE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orUserCodeNotEqualTo(String value) {
        return addOrCriterion("USER_CODE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orUserCodeGreaterThan(String value) {
        return addOrCriterion("USER_CODE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orUserCodeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("USER_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserCodeLessThan(String value) {
        return addOrCriterion("USER_CODE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orUserCodeLessThanOrEqualTo(String value) {
        return addOrCriterion("USER_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserCodeIsNull() {
        return addOrCriterion("USER_CODE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orUserCodeIsNotNull() {
        return addOrCriterion("USER_CODE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orUserCodeLikeBoth(String value) {
        return addOrCriterion("USER_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserCodeLikeLeft(String value) {
        return addOrCriterion("USER_CODE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orUserCodeLikeRigth(String value) {
        return addOrCriterion("USER_CODE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orUserCodeNotLikeBoth(String value) {
        return addOrCriterion("USER_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserCodeNotLikeLeft(String value) {
        return addOrCriterion("USER_CODE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orUserCodeNotLikeRigth(String value) {
        return addOrCriterion("USER_CODE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByUserCode(boolean isDesc) {
        return addOrderBy("USER_CODE", isDesc);
    }

    public IamUserSqlBuilder andPasswordEqualTo(String value) {
        return addAndCriterion("PASSWORD", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andPasswordNotEqualTo(String value) {
        return addAndCriterion("PASSWORD", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andPasswordGreaterThan(String value) {
        return addAndCriterion("PASSWORD", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andPasswordGreaterThanOrEqualTo(String value) {
        return addAndCriterion("PASSWORD", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andPasswordLessThan(String value) {
        return addAndCriterion("PASSWORD", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andPasswordLessThanOrEqualTo(String value) {
        return addAndCriterion("PASSWORD", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andPasswordIsNull() {
        return addAndCriterion("PASSWORD", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andPasswordIsNotNull() {
        return addAndCriterion("PASSWORD", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andPasswordLikeBoth(String value) {
        return addAndCriterion("PASSWORD", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andPasswordLikeLeft(String value) {
        return addAndCriterion("PASSWORD", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andPasswordLikeRigth(String value) {
        return addAndCriterion("PASSWORD", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andPasswordNotLikeBoth(String value) {
        return addAndCriterion("PASSWORD", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andPasswordNotLikeLeft(String value) {
        return addAndCriterion("PASSWORD", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andPasswordNotLikeRigth(String value) {
        return addAndCriterion("PASSWORD", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orPasswordEqualTo(String value) {
        return addOrCriterion("PASSWORD", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orPasswordNotEqualTo(String value) {
        return addOrCriterion("PASSWORD", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orPasswordGreaterThan(String value) {
        return addOrCriterion("PASSWORD", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orPasswordGreaterThanOrEqualTo(String value) {
        return addOrCriterion("PASSWORD", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orPasswordLessThan(String value) {
        return addOrCriterion("PASSWORD", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orPasswordLessThanOrEqualTo(String value) {
        return addOrCriterion("PASSWORD", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orPasswordIsNull() {
        return addOrCriterion("PASSWORD", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orPasswordIsNotNull() {
        return addOrCriterion("PASSWORD", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orPasswordLikeBoth(String value) {
        return addOrCriterion("PASSWORD", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orPasswordLikeLeft(String value) {
        return addOrCriterion("PASSWORD", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orPasswordLikeRigth(String value) {
        return addOrCriterion("PASSWORD", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orPasswordNotLikeBoth(String value) {
        return addOrCriterion("PASSWORD", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orPasswordNotLikeLeft(String value) {
        return addOrCriterion("PASSWORD", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orPasswordNotLikeRigth(String value) {
        return addOrCriterion("PASSWORD", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByPassword(boolean isDesc) {
        return addOrderBy("PASSWORD", isDesc);
    }

    public IamUserSqlBuilder andUserNameEqualTo(String value) {
        return addAndCriterion("USER_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andUserNameNotEqualTo(String value) {
        return addAndCriterion("USER_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andUserNameGreaterThan(String value) {
        return addAndCriterion("USER_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andUserNameGreaterThanOrEqualTo(String value) {
        return addAndCriterion("USER_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserNameLessThan(String value) {
        return addAndCriterion("USER_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andUserNameLessThanOrEqualTo(String value) {
        return addAndCriterion("USER_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUserNameIsNull() {
        return addAndCriterion("USER_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andUserNameIsNotNull() {
        return addAndCriterion("USER_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andUserNameLikeBoth(String value) {
        return addAndCriterion("USER_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserNameLikeLeft(String value) {
        return addAndCriterion("USER_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andUserNameLikeRigth(String value) {
        return addAndCriterion("USER_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andUserNameNotLikeBoth(String value) {
        return addAndCriterion("USER_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUserNameNotLikeLeft(String value) {
        return addAndCriterion("USER_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andUserNameNotLikeRigth(String value) {
        return addAndCriterion("USER_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orUserNameEqualTo(String value) {
        return addOrCriterion("USER_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orUserNameNotEqualTo(String value) {
        return addOrCriterion("USER_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orUserNameGreaterThan(String value) {
        return addOrCriterion("USER_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orUserNameGreaterThanOrEqualTo(String value) {
        return addOrCriterion("USER_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserNameLessThan(String value) {
        return addOrCriterion("USER_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orUserNameLessThanOrEqualTo(String value) {
        return addOrCriterion("USER_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUserNameIsNull() {
        return addOrCriterion("USER_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orUserNameIsNotNull() {
        return addOrCriterion("USER_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orUserNameLikeBoth(String value) {
        return addOrCriterion("USER_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserNameLikeLeft(String value) {
        return addOrCriterion("USER_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orUserNameLikeRigth(String value) {
        return addOrCriterion("USER_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orUserNameNotLikeBoth(String value) {
        return addOrCriterion("USER_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUserNameNotLikeLeft(String value) {
        return addOrCriterion("USER_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orUserNameNotLikeRigth(String value) {
        return addOrCriterion("USER_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByUserName(boolean isDesc) {
        return addOrderBy("USER_NAME", isDesc);
    }

    public IamUserSqlBuilder andAvatarEqualTo(String value) {
        return addAndCriterion("AVATAR", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andAvatarNotEqualTo(String value) {
        return addAndCriterion("AVATAR", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andAvatarGreaterThan(String value) {
        return addAndCriterion("AVATAR", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andAvatarGreaterThanOrEqualTo(String value) {
        return addAndCriterion("AVATAR", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andAvatarLessThan(String value) {
        return addAndCriterion("AVATAR", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andAvatarLessThanOrEqualTo(String value) {
        return addAndCriterion("AVATAR", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andAvatarIsNull() {
        return addAndCriterion("AVATAR", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andAvatarIsNotNull() {
        return addAndCriterion("AVATAR", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andAvatarLikeBoth(String value) {
        return addAndCriterion("AVATAR", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andAvatarLikeLeft(String value) {
        return addAndCriterion("AVATAR", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andAvatarLikeRigth(String value) {
        return addAndCriterion("AVATAR", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andAvatarNotLikeBoth(String value) {
        return addAndCriterion("AVATAR", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andAvatarNotLikeLeft(String value) {
        return addAndCriterion("AVATAR", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andAvatarNotLikeRigth(String value) {
        return addAndCriterion("AVATAR", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orAvatarEqualTo(String value) {
        return addOrCriterion("AVATAR", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orAvatarNotEqualTo(String value) {
        return addOrCriterion("AVATAR", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orAvatarGreaterThan(String value) {
        return addOrCriterion("AVATAR", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orAvatarGreaterThanOrEqualTo(String value) {
        return addOrCriterion("AVATAR", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orAvatarLessThan(String value) {
        return addOrCriterion("AVATAR", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orAvatarLessThanOrEqualTo(String value) {
        return addOrCriterion("AVATAR", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orAvatarIsNull() {
        return addOrCriterion("AVATAR", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orAvatarIsNotNull() {
        return addOrCriterion("AVATAR", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orAvatarLikeBoth(String value) {
        return addOrCriterion("AVATAR", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orAvatarLikeLeft(String value) {
        return addOrCriterion("AVATAR", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orAvatarLikeRigth(String value) {
        return addOrCriterion("AVATAR", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orAvatarNotLikeBoth(String value) {
        return addOrCriterion("AVATAR", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orAvatarNotLikeLeft(String value) {
        return addOrCriterion("AVATAR", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orAvatarNotLikeRigth(String value) {
        return addOrCriterion("AVATAR", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByAvatar(boolean isDesc) {
        return addOrderBy("AVATAR", isDesc);
    }

    public IamUserSqlBuilder andEmailEqualTo(String value) {
        return addAndCriterion("EMAIL", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andEmailNotEqualTo(String value) {
        return addAndCriterion("EMAIL", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andEmailGreaterThan(String value) {
        return addAndCriterion("EMAIL", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andEmailGreaterThanOrEqualTo(String value) {
        return addAndCriterion("EMAIL", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andEmailLessThan(String value) {
        return addAndCriterion("EMAIL", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andEmailLessThanOrEqualTo(String value) {
        return addAndCriterion("EMAIL", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andEmailIsNull() {
        return addAndCriterion("EMAIL", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andEmailIsNotNull() {
        return addAndCriterion("EMAIL", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andEmailLikeBoth(String value) {
        return addAndCriterion("EMAIL", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andEmailLikeLeft(String value) {
        return addAndCriterion("EMAIL", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andEmailLikeRigth(String value) {
        return addAndCriterion("EMAIL", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andEmailNotLikeBoth(String value) {
        return addAndCriterion("EMAIL", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andEmailNotLikeLeft(String value) {
        return addAndCriterion("EMAIL", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andEmailNotLikeRigth(String value) {
        return addAndCriterion("EMAIL", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orEmailEqualTo(String value) {
        return addOrCriterion("EMAIL", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orEmailNotEqualTo(String value) {
        return addOrCriterion("EMAIL", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orEmailGreaterThan(String value) {
        return addOrCriterion("EMAIL", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orEmailGreaterThanOrEqualTo(String value) {
        return addOrCriterion("EMAIL", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orEmailLessThan(String value) {
        return addOrCriterion("EMAIL", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orEmailLessThanOrEqualTo(String value) {
        return addOrCriterion("EMAIL", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orEmailIsNull() {
        return addOrCriterion("EMAIL", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orEmailIsNotNull() {
        return addOrCriterion("EMAIL", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orEmailLikeBoth(String value) {
        return addOrCriterion("EMAIL", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orEmailLikeLeft(String value) {
        return addOrCriterion("EMAIL", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orEmailLikeRigth(String value) {
        return addOrCriterion("EMAIL", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orEmailNotLikeBoth(String value) {
        return addOrCriterion("EMAIL", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orEmailNotLikeLeft(String value) {
        return addOrCriterion("EMAIL", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orEmailNotLikeRigth(String value) {
        return addOrCriterion("EMAIL", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByEmail(boolean isDesc) {
        return addOrderBy("EMAIL", isDesc);
    }

    public IamUserSqlBuilder andMobileEqualTo(String value) {
        return addAndCriterion("MOBILE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andMobileNotEqualTo(String value) {
        return addAndCriterion("MOBILE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andMobileGreaterThan(String value) {
        return addAndCriterion("MOBILE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andMobileGreaterThanOrEqualTo(String value) {
        return addAndCriterion("MOBILE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andMobileLessThan(String value) {
        return addAndCriterion("MOBILE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andMobileLessThanOrEqualTo(String value) {
        return addAndCriterion("MOBILE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andMobileIsNull() {
        return addAndCriterion("MOBILE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andMobileIsNotNull() {
        return addAndCriterion("MOBILE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andMobileLikeBoth(String value) {
        return addAndCriterion("MOBILE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andMobileLikeLeft(String value) {
        return addAndCriterion("MOBILE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andMobileLikeRigth(String value) {
        return addAndCriterion("MOBILE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andMobileNotLikeBoth(String value) {
        return addAndCriterion("MOBILE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andMobileNotLikeLeft(String value) {
        return addAndCriterion("MOBILE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andMobileNotLikeRigth(String value) {
        return addAndCriterion("MOBILE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orMobileEqualTo(String value) {
        return addOrCriterion("MOBILE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orMobileNotEqualTo(String value) {
        return addOrCriterion("MOBILE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orMobileGreaterThan(String value) {
        return addOrCriterion("MOBILE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orMobileGreaterThanOrEqualTo(String value) {
        return addOrCriterion("MOBILE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orMobileLessThan(String value) {
        return addOrCriterion("MOBILE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orMobileLessThanOrEqualTo(String value) {
        return addOrCriterion("MOBILE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orMobileIsNull() {
        return addOrCriterion("MOBILE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orMobileIsNotNull() {
        return addOrCriterion("MOBILE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orMobileLikeBoth(String value) {
        return addOrCriterion("MOBILE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orMobileLikeLeft(String value) {
        return addOrCriterion("MOBILE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orMobileLikeRigth(String value) {
        return addOrCriterion("MOBILE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orMobileNotLikeBoth(String value) {
        return addOrCriterion("MOBILE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orMobileNotLikeLeft(String value) {
        return addOrCriterion("MOBILE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orMobileNotLikeRigth(String value) {
        return addOrCriterion("MOBILE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByMobile(boolean isDesc) {
        return addOrderBy("MOBILE", isDesc);
    }

    public IamUserSqlBuilder andBirthdayEqualTo(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andBirthdayNotEqualTo(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andBirthdayGreaterThan(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andBirthdayGreaterThanOrEqualTo(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andBirthdayLessThan(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andBirthdayLessThanOrEqualTo(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andBirthdayIsNull() {
        return addAndCriterion("BIRTHDAY", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andBirthdayIsNotNull() {
        return addAndCriterion("BIRTHDAY", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andBirthdayLikeBoth(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andBirthdayLikeLeft(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andBirthdayLikeRigth(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andBirthdayNotLikeBoth(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andBirthdayNotLikeLeft(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andBirthdayNotLikeRigth(Date value) {
        return addAndCriterion("BIRTHDAY", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orBirthdayEqualTo(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orBirthdayNotEqualTo(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orBirthdayGreaterThan(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orBirthdayGreaterThanOrEqualTo(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orBirthdayLessThan(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orBirthdayLessThanOrEqualTo(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orBirthdayIsNull() {
        return addOrCriterion("BIRTHDAY", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orBirthdayIsNotNull() {
        return addOrCriterion("BIRTHDAY", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orBirthdayLikeBoth(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orBirthdayLikeLeft(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orBirthdayLikeRigth(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orBirthdayNotLikeBoth(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orBirthdayNotLikeLeft(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orBirthdayNotLikeRigth(Date value) {
        return addOrCriterion("BIRTHDAY", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByBirthday(boolean isDesc) {
        return addOrderBy("BIRTHDAY", isDesc);
    }

    public IamUserSqlBuilder andSexEqualTo(String value) {
        return addAndCriterion("SEX", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andSexNotEqualTo(String value) {
        return addAndCriterion("SEX", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andSexGreaterThan(String value) {
        return addAndCriterion("SEX", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andSexGreaterThanOrEqualTo(String value) {
        return addAndCriterion("SEX", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andSexLessThan(String value) {
        return addAndCriterion("SEX", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andSexLessThanOrEqualTo(String value) {
        return addAndCriterion("SEX", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andSexIsNull() {
        return addAndCriterion("SEX", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andSexIsNotNull() {
        return addAndCriterion("SEX", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andSexLikeBoth(String value) {
        return addAndCriterion("SEX", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andSexLikeLeft(String value) {
        return addAndCriterion("SEX", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andSexLikeRigth(String value) {
        return addAndCriterion("SEX", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andSexNotLikeBoth(String value) {
        return addAndCriterion("SEX", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andSexNotLikeLeft(String value) {
        return addAndCriterion("SEX", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andSexNotLikeRigth(String value) {
        return addAndCriterion("SEX", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orSexEqualTo(String value) {
        return addOrCriterion("SEX", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orSexNotEqualTo(String value) {
        return addOrCriterion("SEX", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orSexGreaterThan(String value) {
        return addOrCriterion("SEX", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orSexGreaterThanOrEqualTo(String value) {
        return addOrCriterion("SEX", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orSexLessThan(String value) {
        return addOrCriterion("SEX", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orSexLessThanOrEqualTo(String value) {
        return addOrCriterion("SEX", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orSexIsNull() {
        return addOrCriterion("SEX", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orSexIsNotNull() {
        return addOrCriterion("SEX", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orSexLikeBoth(String value) {
        return addOrCriterion("SEX", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orSexLikeLeft(String value) {
        return addOrCriterion("SEX", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orSexLikeRigth(String value) {
        return addOrCriterion("SEX", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orSexNotLikeBoth(String value) {
        return addOrCriterion("SEX", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orSexNotLikeLeft(String value) {
        return addOrCriterion("SEX", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orSexNotLikeRigth(String value) {
        return addOrCriterion("SEX", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderBySex(boolean isDesc) {
        return addOrderBy("SEX", isDesc);
    }

    public IamUserSqlBuilder andIdNumberEqualTo(String value) {
        return addAndCriterion("ID_NUMBER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andIdNumberNotEqualTo(String value) {
        return addAndCriterion("ID_NUMBER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andIdNumberGreaterThan(String value) {
        return addAndCriterion("ID_NUMBER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andIdNumberGreaterThanOrEqualTo(String value) {
        return addAndCriterion("ID_NUMBER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIdNumberLessThan(String value) {
        return addAndCriterion("ID_NUMBER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andIdNumberLessThanOrEqualTo(String value) {
        return addAndCriterion("ID_NUMBER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIdNumberIsNull() {
        return addAndCriterion("ID_NUMBER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andIdNumberIsNotNull() {
        return addAndCriterion("ID_NUMBER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andIdNumberLikeBoth(String value) {
        return addAndCriterion("ID_NUMBER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIdNumberLikeLeft(String value) {
        return addAndCriterion("ID_NUMBER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andIdNumberLikeRigth(String value) {
        return addAndCriterion("ID_NUMBER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andIdNumberNotLikeBoth(String value) {
        return addAndCriterion("ID_NUMBER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIdNumberNotLikeLeft(String value) {
        return addAndCriterion("ID_NUMBER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andIdNumberNotLikeRigth(String value) {
        return addAndCriterion("ID_NUMBER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orIdNumberEqualTo(String value) {
        return addOrCriterion("ID_NUMBER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orIdNumberNotEqualTo(String value) {
        return addOrCriterion("ID_NUMBER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orIdNumberGreaterThan(String value) {
        return addOrCriterion("ID_NUMBER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orIdNumberGreaterThanOrEqualTo(String value) {
        return addOrCriterion("ID_NUMBER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIdNumberLessThan(String value) {
        return addOrCriterion("ID_NUMBER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orIdNumberLessThanOrEqualTo(String value) {
        return addOrCriterion("ID_NUMBER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIdNumberIsNull() {
        return addOrCriterion("ID_NUMBER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orIdNumberIsNotNull() {
        return addOrCriterion("ID_NUMBER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orIdNumberLikeBoth(String value) {
        return addOrCriterion("ID_NUMBER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIdNumberLikeLeft(String value) {
        return addOrCriterion("ID_NUMBER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orIdNumberLikeRigth(String value) {
        return addOrCriterion("ID_NUMBER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orIdNumberNotLikeBoth(String value) {
        return addOrCriterion("ID_NUMBER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIdNumberNotLikeLeft(String value) {
        return addOrCriterion("ID_NUMBER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orIdNumberNotLikeRigth(String value) {
        return addOrCriterion("ID_NUMBER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByIdNumber(boolean isDesc) {
        return addOrderBy("ID_NUMBER", isDesc);
    }

    public IamUserSqlBuilder andOrganIdEqualTo(String value) {
        return addAndCriterion("ORGAN_ID", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andOrganIdNotEqualTo(String value) {
        return addAndCriterion("ORGAN_ID", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andOrganIdGreaterThan(String value) {
        return addAndCriterion("ORGAN_ID", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andOrganIdGreaterThanOrEqualTo(String value) {
        return addAndCriterion("ORGAN_ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andOrganIdLessThan(String value) {
        return addAndCriterion("ORGAN_ID", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andOrganIdLessThanOrEqualTo(String value) {
        return addAndCriterion("ORGAN_ID", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andOrganIdIsNull() {
        return addAndCriterion("ORGAN_ID", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andOrganIdIsNotNull() {
        return addAndCriterion("ORGAN_ID", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andOrganIdLikeBoth(String value) {
        return addAndCriterion("ORGAN_ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andOrganIdLikeLeft(String value) {
        return addAndCriterion("ORGAN_ID", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andOrganIdLikeRigth(String value) {
        return addAndCriterion("ORGAN_ID", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andOrganIdNotLikeBoth(String value) {
        return addAndCriterion("ORGAN_ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andOrganIdNotLikeLeft(String value) {
        return addAndCriterion("ORGAN_ID", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andOrganIdNotLikeRigth(String value) {
        return addAndCriterion("ORGAN_ID", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orOrganIdEqualTo(String value) {
        return addOrCriterion("ORGAN_ID", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orOrganIdNotEqualTo(String value) {
        return addOrCriterion("ORGAN_ID", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orOrganIdGreaterThan(String value) {
        return addOrCriterion("ORGAN_ID", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orOrganIdGreaterThanOrEqualTo(String value) {
        return addOrCriterion("ORGAN_ID", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orOrganIdLessThan(String value) {
        return addOrCriterion("ORGAN_ID", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orOrganIdLessThanOrEqualTo(String value) {
        return addOrCriterion("ORGAN_ID", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orOrganIdIsNull() {
        return addOrCriterion("ORGAN_ID", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orOrganIdIsNotNull() {
        return addOrCriterion("ORGAN_ID", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orOrganIdLikeBoth(String value) {
        return addOrCriterion("ORGAN_ID", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orOrganIdLikeLeft(String value) {
        return addOrCriterion("ORGAN_ID", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orOrganIdLikeRigth(String value) {
        return addOrCriterion("ORGAN_ID", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orOrganIdNotLikeBoth(String value) {
        return addOrCriterion("ORGAN_ID", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orOrganIdNotLikeLeft(String value) {
        return addOrCriterion("ORGAN_ID", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orOrganIdNotLikeRigth(String value) {
        return addOrCriterion("ORGAN_ID", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByOrganId(boolean isDesc) {
        return addOrderBy("ORGAN_ID", isDesc);
    }

    public IamUserSqlBuilder andOrganNameEqualTo(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andOrganNameNotEqualTo(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andOrganNameGreaterThan(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andOrganNameGreaterThanOrEqualTo(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andOrganNameLessThan(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andOrganNameLessThanOrEqualTo(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andOrganNameIsNull() {
        return addAndCriterion("ORGAN_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andOrganNameIsNotNull() {
        return addAndCriterion("ORGAN_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andOrganNameLikeBoth(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andOrganNameLikeLeft(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andOrganNameLikeRigth(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andOrganNameNotLikeBoth(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andOrganNameNotLikeLeft(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andOrganNameNotLikeRigth(String value) {
        return addAndCriterion("ORGAN_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orOrganNameEqualTo(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orOrganNameNotEqualTo(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orOrganNameGreaterThan(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orOrganNameGreaterThanOrEqualTo(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orOrganNameLessThan(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orOrganNameLessThanOrEqualTo(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orOrganNameIsNull() {
        return addOrCriterion("ORGAN_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orOrganNameIsNotNull() {
        return addOrCriterion("ORGAN_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orOrganNameLikeBoth(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orOrganNameLikeLeft(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orOrganNameLikeRigth(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orOrganNameNotLikeBoth(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orOrganNameNotLikeLeft(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orOrganNameNotLikeRigth(String value) {
        return addOrCriterion("ORGAN_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByOrganName(boolean isDesc) {
        return addOrderBy("ORGAN_NAME", isDesc);
    }

    public IamUserSqlBuilder andTenantCodeEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andTenantCodeNotEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andTenantCodeGreaterThan(String value) {
        return addAndCriterion("TENANT_CODE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andTenantCodeGreaterThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andTenantCodeLessThan(String value) {
        return addAndCriterion("TENANT_CODE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andTenantCodeLessThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andTenantCodeIsNull() {
        return addAndCriterion("TENANT_CODE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andTenantCodeIsNotNull() {
        return addAndCriterion("TENANT_CODE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andTenantCodeLikeBoth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andTenantCodeLikeLeft(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andTenantCodeLikeRigth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andTenantCodeNotLikeBoth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andTenantCodeNotLikeLeft(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andTenantCodeNotLikeRigth(String value) {
        return addAndCriterion("TENANT_CODE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orTenantCodeEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orTenantCodeNotEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orTenantCodeGreaterThan(String value) {
        return addOrCriterion("TENANT_CODE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orTenantCodeGreaterThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orTenantCodeLessThan(String value) {
        return addOrCriterion("TENANT_CODE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orTenantCodeLessThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_CODE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orTenantCodeIsNull() {
        return addOrCriterion("TENANT_CODE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orTenantCodeIsNotNull() {
        return addOrCriterion("TENANT_CODE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orTenantCodeLikeBoth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orTenantCodeLikeLeft(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orTenantCodeLikeRigth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orTenantCodeNotLikeBoth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orTenantCodeNotLikeLeft(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orTenantCodeNotLikeRigth(String value) {
        return addOrCriterion("TENANT_CODE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByTenantCode(boolean isDesc) {
        return addOrderBy("TENANT_CODE", isDesc);
    }

    public IamUserSqlBuilder andTenantNameEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andTenantNameNotEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andTenantNameGreaterThan(String value) {
        return addAndCriterion("TENANT_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andTenantNameGreaterThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andTenantNameLessThan(String value) {
        return addAndCriterion("TENANT_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andTenantNameLessThanOrEqualTo(String value) {
        return addAndCriterion("TENANT_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andTenantNameIsNull() {
        return addAndCriterion("TENANT_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andTenantNameIsNotNull() {
        return addAndCriterion("TENANT_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andTenantNameLikeBoth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andTenantNameLikeLeft(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andTenantNameLikeRigth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andTenantNameNotLikeBoth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andTenantNameNotLikeLeft(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andTenantNameNotLikeRigth(String value) {
        return addAndCriterion("TENANT_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orTenantNameEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orTenantNameNotEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orTenantNameGreaterThan(String value) {
        return addOrCriterion("TENANT_NAME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orTenantNameGreaterThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orTenantNameLessThan(String value) {
        return addOrCriterion("TENANT_NAME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orTenantNameLessThanOrEqualTo(String value) {
        return addOrCriterion("TENANT_NAME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orTenantNameIsNull() {
        return addOrCriterion("TENANT_NAME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orTenantNameIsNotNull() {
        return addOrCriterion("TENANT_NAME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orTenantNameLikeBoth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orTenantNameLikeLeft(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orTenantNameLikeRigth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orTenantNameNotLikeBoth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orTenantNameNotLikeLeft(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orTenantNameNotLikeRigth(String value) {
        return addOrCriterion("TENANT_NAME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByTenantName(boolean isDesc) {
        return addOrderBy("TENANT_NAME", isDesc);
    }

    public IamUserSqlBuilder andStateEqualTo(String value) {
        return addAndCriterion("STATE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andStateNotEqualTo(String value) {
        return addAndCriterion("STATE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andStateGreaterThan(String value) {
        return addAndCriterion("STATE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andStateGreaterThanOrEqualTo(String value) {
        return addAndCriterion("STATE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andStateLessThan(String value) {
        return addAndCriterion("STATE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andStateLessThanOrEqualTo(String value) {
        return addAndCriterion("STATE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andStateIsNull() {
        return addAndCriterion("STATE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andStateIsNotNull() {
        return addAndCriterion("STATE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andStateLikeBoth(String value) {
        return addAndCriterion("STATE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andStateLikeLeft(String value) {
        return addAndCriterion("STATE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andStateLikeRigth(String value) {
        return addAndCriterion("STATE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andStateNotLikeBoth(String value) {
        return addAndCriterion("STATE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andStateNotLikeLeft(String value) {
        return addAndCriterion("STATE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andStateNotLikeRigth(String value) {
        return addAndCriterion("STATE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orStateEqualTo(String value) {
        return addOrCriterion("STATE", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orStateNotEqualTo(String value) {
        return addOrCriterion("STATE", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orStateGreaterThan(String value) {
        return addOrCriterion("STATE", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orStateGreaterThanOrEqualTo(String value) {
        return addOrCriterion("STATE", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orStateLessThan(String value) {
        return addOrCriterion("STATE", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orStateLessThanOrEqualTo(String value) {
        return addOrCriterion("STATE", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orStateIsNull() {
        return addOrCriterion("STATE", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orStateIsNotNull() {
        return addOrCriterion("STATE", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orStateLikeBoth(String value) {
        return addOrCriterion("STATE", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orStateLikeLeft(String value) {
        return addOrCriterion("STATE", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orStateLikeRigth(String value) {
        return addOrCriterion("STATE", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orStateNotLikeBoth(String value) {
        return addOrCriterion("STATE", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orStateNotLikeLeft(String value) {
        return addOrCriterion("STATE", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orStateNotLikeRigth(String value) {
        return addOrCriterion("STATE", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByState(boolean isDesc) {
        return addOrderBy("STATE", isDesc);
    }

    public IamUserSqlBuilder andCreateUserEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andCreateUserNotEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andCreateUserGreaterThan(String value) {
        return addAndCriterion("CREATE_USER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andCreateUserGreaterThanOrEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andCreateUserLessThan(String value) {
        return addAndCriterion("CREATE_USER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andCreateUserLessThanOrEqualTo(String value) {
        return addAndCriterion("CREATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andCreateUserIsNull() {
        return addAndCriterion("CREATE_USER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andCreateUserIsNotNull() {
        return addAndCriterion("CREATE_USER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andCreateUserLikeBoth(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andCreateUserLikeLeft(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andCreateUserLikeRigth(String value) {
        return addAndCriterion("CREATE_USER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andCreateUserNotLikeBoth(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andCreateUserNotLikeLeft(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andCreateUserNotLikeRigth(String value) {
        return addAndCriterion("CREATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orCreateUserEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orCreateUserNotEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orCreateUserGreaterThan(String value) {
        return addOrCriterion("CREATE_USER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orCreateUserGreaterThanOrEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orCreateUserLessThan(String value) {
        return addOrCriterion("CREATE_USER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orCreateUserLessThanOrEqualTo(String value) {
        return addOrCriterion("CREATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orCreateUserIsNull() {
        return addOrCriterion("CREATE_USER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orCreateUserIsNotNull() {
        return addOrCriterion("CREATE_USER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orCreateUserLikeBoth(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orCreateUserLikeLeft(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orCreateUserLikeRigth(String value) {
        return addOrCriterion("CREATE_USER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orCreateUserNotLikeBoth(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orCreateUserNotLikeLeft(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orCreateUserNotLikeRigth(String value) {
        return addOrCriterion("CREATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByCreateUser(boolean isDesc) {
        return addOrderBy("CREATE_USER", isDesc);
    }

    public IamUserSqlBuilder andUpdateUserEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andUpdateUserNotEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateUserGreaterThan(String value) {
        return addAndCriterion("UPDATE_USER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andUpdateUserGreaterThanOrEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateUserLessThan(String value) {
        return addAndCriterion("UPDATE_USER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andUpdateUserLessThanOrEqualTo(String value) {
        return addAndCriterion("UPDATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateUserIsNull() {
        return addAndCriterion("UPDATE_USER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andUpdateUserIsNotNull() {
        return addAndCriterion("UPDATE_USER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andUpdateUserLikeBoth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUpdateUserLikeLeft(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andUpdateUserLikeRigth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andUpdateUserNotLikeBoth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUpdateUserNotLikeLeft(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andUpdateUserNotLikeRigth(String value) {
        return addAndCriterion("UPDATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orUpdateUserEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orUpdateUserNotEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateUserGreaterThan(String value) {
        return addOrCriterion("UPDATE_USER", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orUpdateUserGreaterThanOrEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateUserLessThan(String value) {
        return addOrCriterion("UPDATE_USER", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orUpdateUserLessThanOrEqualTo(String value) {
        return addOrCriterion("UPDATE_USER", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateUserIsNull() {
        return addOrCriterion("UPDATE_USER", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orUpdateUserIsNotNull() {
        return addOrCriterion("UPDATE_USER", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orUpdateUserLikeBoth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUpdateUserLikeLeft(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orUpdateUserLikeRigth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orUpdateUserNotLikeBoth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUpdateUserNotLikeLeft(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orUpdateUserNotLikeRigth(String value) {
        return addOrCriterion("UPDATE_USER", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByUpdateUser(boolean isDesc) {
        return addOrderBy("UPDATE_USER", isDesc);
    }

    public IamUserSqlBuilder andCreateTimeEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andCreateTimeNotEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andCreateTimeGreaterThan(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andCreateTimeGreaterThanOrEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andCreateTimeLessThan(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andCreateTimeLessThanOrEqualTo(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andCreateTimeIsNull() {
        return addAndCriterion("CREATE_TIME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andCreateTimeIsNotNull() {
        return addAndCriterion("CREATE_TIME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andCreateTimeLikeBoth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andCreateTimeLikeLeft(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andCreateTimeLikeRigth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andCreateTimeNotLikeBoth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andCreateTimeNotLikeLeft(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andCreateTimeNotLikeRigth(Date value) {
        return addAndCriterion("CREATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orCreateTimeEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orCreateTimeNotEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orCreateTimeGreaterThan(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orCreateTimeGreaterThanOrEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orCreateTimeLessThan(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orCreateTimeLessThanOrEqualTo(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orCreateTimeIsNull() {
        return addOrCriterion("CREATE_TIME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orCreateTimeIsNotNull() {
        return addOrCriterion("CREATE_TIME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orCreateTimeLikeBoth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orCreateTimeLikeLeft(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orCreateTimeLikeRigth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orCreateTimeNotLikeBoth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orCreateTimeNotLikeLeft(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orCreateTimeNotLikeRigth(Date value) {
        return addOrCriterion("CREATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByCreateTime(boolean isDesc) {
        return addOrderBy("CREATE_TIME", isDesc);
    }

    public IamUserSqlBuilder andUpdateTimeEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andUpdateTimeNotEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateTimeGreaterThan(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andUpdateTimeGreaterThanOrEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateTimeLessThan(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andUpdateTimeLessThanOrEqualTo(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andUpdateTimeIsNull() {
        return addAndCriterion("UPDATE_TIME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andUpdateTimeIsNotNull() {
        return addAndCriterion("UPDATE_TIME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andUpdateTimeLikeBoth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUpdateTimeLikeLeft(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andUpdateTimeLikeRigth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andUpdateTimeNotLikeBoth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andUpdateTimeNotLikeLeft(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andUpdateTimeNotLikeRigth(Date value) {
        return addAndCriterion("UPDATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orUpdateTimeEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orUpdateTimeNotEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateTimeGreaterThan(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orUpdateTimeGreaterThanOrEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateTimeLessThan(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orUpdateTimeLessThanOrEqualTo(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orUpdateTimeIsNull() {
        return addOrCriterion("UPDATE_TIME", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orUpdateTimeIsNotNull() {
        return addOrCriterion("UPDATE_TIME", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orUpdateTimeLikeBoth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUpdateTimeLikeLeft(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orUpdateTimeLikeRigth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orUpdateTimeNotLikeBoth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orUpdateTimeNotLikeLeft(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orUpdateTimeNotLikeRigth(Date value) {
        return addOrCriterion("UPDATE_TIME", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByUpdateTime(boolean isDesc) {
        return addOrderBy("UPDATE_TIME", isDesc);
    }

    public IamUserSqlBuilder andIsDeletedEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder andIsDeletedNotEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder andIsDeletedGreaterThan(String value) {
        return addAndCriterion("IS_DELETED", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder andIsDeletedGreaterThanOrEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIsDeletedLessThan(String value) {
        return addAndCriterion("IS_DELETED", Operator.LessThan, value);
    }

    public IamUserSqlBuilder andIsDeletedLessThanOrEqualTo(String value) {
        return addAndCriterion("IS_DELETED", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder andIsDeletedIsNull() {
        return addAndCriterion("IS_DELETED", Operator.IsNull, null);
    }

    public IamUserSqlBuilder andIsDeletedIsNotNull() {
        return addAndCriterion("IS_DELETED", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder andIsDeletedLikeBoth(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIsDeletedLikeLeft(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder andIsDeletedLikeRigth(String value) {
        return addAndCriterion("IS_DELETED", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder andIsDeletedNotLikeBoth(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder andIsDeletedNotLikeLeft(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder andIsDeletedNotLikeRigth(String value) {
        return addAndCriterion("IS_DELETED", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orIsDeletedEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.EqualTo, value);
    }

    public IamUserSqlBuilder orIsDeletedNotEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotEqualTo, value);
    }

    public IamUserSqlBuilder orIsDeletedGreaterThan(String value) {
        return addOrCriterion("IS_DELETED", Operator.GreaterThan, value);
    }

    public IamUserSqlBuilder orIsDeletedGreaterThanOrEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.GreaterThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIsDeletedLessThan(String value) {
        return addOrCriterion("IS_DELETED", Operator.LessThan, value);
    }

    public IamUserSqlBuilder orIsDeletedLessThanOrEqualTo(String value) {
        return addOrCriterion("IS_DELETED", Operator.LessThanOrEqualTo, value);
    }

    public IamUserSqlBuilder orIsDeletedIsNull() {
        return addOrCriterion("IS_DELETED", Operator.IsNull, null);
    }

    public IamUserSqlBuilder orIsDeletedIsNotNull() {
        return addOrCriterion("IS_DELETED", Operator.IsNotNull, null);
    }

    public IamUserSqlBuilder orIsDeletedLikeBoth(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIsDeletedLikeLeft(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, likeMark + value);
    }

    public IamUserSqlBuilder orIsDeletedLikeRigth(String value) {
        return addOrCriterion("IS_DELETED", Operator.Like, value + likeMark);
    }

    public IamUserSqlBuilder orIsDeletedNotLikeBoth(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamUserSqlBuilder orIsDeletedNotLikeLeft(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, likeMark + value);
    }

    public IamUserSqlBuilder orIsDeletedNotLikeRigth(String value) {
        return addOrCriterion("IS_DELETED", Operator.NotLike, value + likeMark);
    }

    public IamUserSqlBuilder orderByIsDeleted(boolean isDesc) {
        return addOrderBy("IS_DELETED", isDesc);
    }
}